home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 98 / Skunkware 98.iso / src / fileutil / fileutils-3.16.tar.gz / fileutils-3.16.tar / fileutils-3.16 / lib / mountlist.c < prev    next >
C/C++ Source or Header  |  1997-01-25  |  14KB  |  578 lines
  1. /* mountlist.c -- return a list of mounted filesystems
  2.    Copyright (C) 1991, 1992 Free Software Foundation, Inc.
  3.  
  4.    This program is free software; you can redistribute it and/or modify
  5.    it under the terms of the GNU General Public License as published by
  6.    the Free Software Foundation; either version 2, or (at your option)
  7.    any later version.
  8.  
  9.    This program is distributed in the hope that it will be useful,
  10.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.    GNU General Public License for more details.
  13.  
  14.    You should have received a copy of the GNU General Public License
  15.    along with this program; if not, write to the Free Software Foundation,
  16.    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17.  
  18. #ifdef HAVE_CONFIG_H
  19. #include <config.h>
  20. #endif
  21.  
  22. #include <stdio.h>
  23. #include <sys/types.h>
  24. #include "mountlist.h"
  25.  
  26. #ifdef STDC_HEADERS
  27. #include <stdlib.h>
  28. #else
  29. void free ();
  30. #endif
  31. #if defined(STDC_HEADERS) || defined(HAVE_STRING_H)
  32. #include <string.h>
  33. #else
  34. #include <strings.h>
  35. #endif
  36.  
  37. char *strstr ();
  38. char *xmalloc ();
  39. char *xrealloc ();
  40. char *xstrdup ();
  41. void error ();
  42.  
  43. #ifdef HAVE_SYS_PARAM_H
  44. #include <sys/param.h>
  45. #endif
  46.  
  47. #if defined (MOUNTED_GETFSSTAT)    /* __alpha running OSF_1 */
  48. #  include <sys/mount.h>
  49. #  include <sys/fs_types.h>
  50. #endif /* MOUNTED_GETFSSTAT */
  51.  
  52. #ifdef MOUNTED_GETMNTENT1    /* 4.3BSD, SunOS, HP-UX, Dynix, Irix.  */
  53. #include <mntent.h>
  54. #if !defined(MOUNTED)
  55. #  if defined(MNT_MNTTAB)    /* HP-UX.  */
  56. #    define MOUNTED MNT_MNTTAB
  57. #  endif
  58. #  if defined(MNTTABNAME)    /* Dynix.  */
  59. #    define MOUNTED MNTTABNAME
  60. #  endif
  61. #endif
  62. #endif
  63.  
  64. #ifdef MOUNTED_GETMNTINFO    /* 4.4BSD.  */
  65. #include <sys/mount.h>
  66. #endif
  67.  
  68. #ifdef MOUNTED_GETMNT        /* Ultrix.  */
  69. #include <sys/mount.h>
  70. #include <sys/fs_types.h>
  71. #endif
  72.  
  73. #ifdef MOUNTED_FREAD        /* SVR2.  */
  74. #include <mnttab.h>
  75. #endif
  76.  
  77. #ifdef MOUNTED_FREAD_FSTYP    /* SVR3.  */
  78. #include <mnttab.h>
  79. #include <sys/fstyp.h>
  80. #include <sys/statfs.h>
  81. #endif
  82.  
  83. #ifdef MOUNTED_LISTMNTENT
  84. #include <mntent.h>
  85. #endif
  86.  
  87. #ifdef MOUNTED_GETMNTENT2    /* SVR4.  */
  88. #include <sys/mnttab.h>
  89. #endif
  90.  
  91. #ifdef MOUNTED_VMOUNT        /* AIX.  */
  92. #include <fshelp.h>
  93. #include <sys/vfs.h>
  94. #endif
  95.  
  96. #ifdef DOLPHIN
  97. /* So special that it's not worth putting this in autoconf.  */
  98. #undef MOUNTED_FREAD_FSTYP
  99. #define MOUNTED_GETMNTTBL
  100. #endif
  101.  
  102. #ifdef MOUNTED_GETMNTENT1    /* 4.3BSD, SunOS, HP-UX, Dynix, Irix.  */
  103. /* Return the value of the hexadecimal number represented by CP.
  104.    No prefix (like '0x') or suffix (like 'h') is expected to be
  105.    part of CP. */
  106.  
  107. static int
  108. xatoi (cp)
  109.      char *cp;
  110. {
  111.   int val;
  112.  
  113.   val = 0;
  114.   while (*cp)
  115.     {
  116.       if (*cp >= 'a' && *cp <= 'f')
  117.     val = val * 16 + *cp - 'a' + 10;
  118.       else if (*cp >= 'A' && *cp <= 'F')
  119.     val = val * 16 + *cp - 'A' + 10;
  120.       else if (*cp >= '0' && *cp <= '9')
  121.     val = val * 16 + *cp - '0';
  122.       else
  123.     break;
  124.       cp++;
  125.     }
  126.   return val;
  127. }
  128. #endif /* MOUNTED_GETMNTENT1.  */
  129.  
  130. #if defined (MOUNTED_GETMNTINFO) && !defined (__NetBSD__)
  131. static char *
  132. fstype_to_string (t)
  133.      short t;
  134. {
  135.   switch (t)
  136.     {
  137. #ifdef MOUNT_PC
  138.     case MOUNT_PC:
  139.       return "pc";
  140. #endif
  141. #ifdef MOUNT_MFS
  142.     case MOUNT_MFS:
  143.       return "mfs";
  144. #endif
  145. #ifdef MOUNT_LO
  146.     case MOUNT_LO:
  147.       return "lo";
  148. #endif
  149. #ifdef MOUNT_TFS
  150.     case MOUNT_TFS:
  151.       return "tfs";
  152. #endif
  153. #ifdef MOUNT_TMP
  154.     case MOUNT_TMP:
  155.       return "tmp";
  156. #endif
  157. #ifdef MOUNT_UFS
  158.    case MOUNT_UFS:
  159.      return "ufs" ;
  160. #endif
  161. #ifdef MOUNT_NFS
  162.    case MOUNT_NFS:
  163.      return "nfs" ;
  164. #endif
  165. #ifdef MOUNT_MSDOS
  166.    case MOUNT_MSDOS:
  167.      return "msdos" ;
  168. #endif
  169. #ifdef MOUNT_LFS
  170.    case MOUNT_LFS:
  171.      return "lfs" ;
  172. #endif
  173. #ifdef MOUNT_LOFS
  174.    case MOUNT_LOFS:
  175.      return "lofs" ;
  176. #endif
  177. #ifdef MOUNT_FDESC
  178.    case MOUNT_FDESC:
  179.      return "fdesc" ;
  180. #endif
  181. #ifdef MOUNT_PORTAL
  182.    case MOUNT_PORTAL:
  183.      return "portal" ;
  184. #endif
  185. #ifdef MOUNT_NULL
  186.    case MOUNT_NULL:
  187.      return "null" ;
  188. #endif
  189. #ifdef MOUNT_UMAP
  190.    case MOUNT_UMAP:
  191.      return "umap" ;
  192. #endif
  193. #ifdef MOUNT_KERNFS
  194.    case MOUNT_KERNFS:
  195.      return "kernfs" ;
  196. #endif
  197. #ifdef MOUNT_PROCFS
  198.    case MOUNT_PROCFS:
  199.      return "procfs" ;
  200. #endif
  201. #ifdef MOUNT_AFS
  202.    case MOUNT_AFS:
  203.      return "afs" ;
  204. #endif
  205. #ifdef MOUNT_CD9660
  206.    case MOUNT_CD9660:
  207.      return "cd9660" ;
  208. #endif
  209. #ifdef MOUNT_UNION
  210.    case MOUNT_UNION:
  211.      return "union" ;
  212. #endif
  213. #ifdef MOUNT_DEVFS
  214.    case MOUNT_DEVFS:
  215.      return "devfs" ;
  216. #endif
  217. #ifdef MOUNT_EXT2FS
  218.    case MOUNT_EXT2FS:
  219.      return "ext2fs" ;
  220. #endif
  221.     default:
  222.       return "?";
  223.     }
  224. }
  225. #endif /* MOUNTED_GETMNTINFO */
  226.  
  227. #ifdef MOUNTED_VMOUNT        /* AIX.  */
  228. static char *
  229. fstype_to_string (t)
  230.      int t;
  231. {
  232.   struct vfs_ent *e;
  233.  
  234.   e = getvfsbytype (t);
  235.   if (!e || !e->vfsent_name)
  236.     return "none";
  237.   else
  238.     return e->vfsent_name;
  239. }
  240. #endif /* MOUNTED_VMOUNT */
  241.  
  242. /* Return a list of the currently mounted filesystems, or NULL on error.
  243.    Add each entry to the tail of the list so that they stay in order.
  244.    If NEED_FS_TYPE is nonzero, ensure that the filesystem type fields in
  245.    the returned list are valid.  Otherwise, they might not be.
  246.    If ALL_FS is zero, do not return entries for filesystems that
  247.    are automounter (dummy) entries.  */
  248.  
  249. struct mount_entry *
  250. read_filesystem_list (need_fs_type, all_fs)
  251.      int need_fs_type, all_fs;
  252. {
  253.   struct mount_entry *mount_list;
  254.   struct mount_entry *me;
  255.   struct mount_entry *mtail;
  256.  
  257.   /* Start the list off with a dummy entry. */
  258.   me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
  259.   me->me_next = NULL;
  260.   mount_list = mtail = me;
  261.  
  262. #ifdef MOUNTED_LISTMNTENT
  263.   {
  264.     struct tabmntent *mntlist, *p;
  265.     struct mntent *mnt;
  266.     struct mount_entry *me;
  267.  
  268.     /* the third and fourth arguments could be used to filter mounts,
  269.        but Crays doesn't seem to have any mounts that we want to
  270.        remove. Specifically, automount create normal NFS mounts.
  271.        */
  272.  
  273.     if(listmntent(&mntlist, KMTAB, NULL, NULL) < 0)
  274.       return NULL;
  275.     p = mntlist;
  276.     while(p){
  277.       mnt = p->ment;
  278.       me = (struct mount_entry*) xmalloc(sizeof (struct mount_entry));
  279.       me->me_devname = xstrdup(mnt->mnt_fsname);
  280.       me->me_mountdir = xstrdup(mnt->mnt_dir);
  281.       me->me_type = xstrdup(mnt->mnt_type);
  282.       me->me_dev = -1;
  283.       me->me_next = NULL;
  284.       mtail->me_next = me;
  285.       mtail = me;
  286.       p = p->next;
  287.     }
  288.     freemntlist(mntlist);
  289.   }
  290. #endif
  291.  
  292. #ifdef MOUNTED_GETMNTENT1    /* 4.3BSD, SunOS, HP-UX, Dynix, Irix.  */
  293.   {
  294.     struct mntent *mnt;
  295.     char *table = MOUNTED;
  296.     FILE *fp;
  297.     char *devopt;
  298.  
  299.     fp = setmntent (table, "r");
  300.     if (fp == NULL)
  301.       return NULL;
  302.  
  303.     while ((mnt = getmntent (fp)))
  304.       {
  305.     if (!all_fs && (!strcmp (mnt->mnt_type, "ignore")
  306.             || !strcmp (mnt->mnt_type, "auto")))
  307.       continue;
  308.  
  309.     me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
  310.     me->me_devname = xstrdup (mnt->mnt_fsname);
  311.     me->me_mountdir = xstrdup (mnt->mnt_dir);
  312.     me->me_type = xstrdup (mnt->mnt_type);
  313.     devopt = strstr (mnt->mnt_opts, "dev=");
  314.     if (devopt)
  315.       {
  316.         if (devopt[4] == '0' && (devopt[5] == 'x' || devopt[5] == 'X'))
  317.           me->me_dev = xatoi (devopt + 6);
  318.         else
  319.           me->me_dev = xatoi (devopt + 4);
  320.       }
  321.     else
  322.       me->me_dev = (dev_t) -1;    /* Magic; means not known yet. */
  323.     me->me_next = NULL;
  324.  
  325.     /* Add to the linked list. */
  326.     mtail->me_next = me;
  327.     mtail = me;
  328.       }
  329.  
  330.     if (endmntent (fp) == 0)
  331.       return NULL;
  332.   }
  333. #endif /* MOUNTED_GETMNTENT1. */
  334.  
  335. #ifdef MOUNTED_GETMNTINFO    /* 4.4BSD.  */
  336.   {
  337.     struct statfs *fsp;
  338.     int entries;
  339.  
  340.     entries = getmntinfo (&fsp, MNT_NOWAIT);
  341.     if (entries < 0)
  342.       return NULL;
  343.     while (entries-- > 0)
  344.       {
  345.     me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
  346.     me->me_devname = xstrdup (fsp->f_mntfromname);
  347.     me->me_mountdir = xstrdup (fsp->f_mntonname);
  348. #ifdef __NetBSD__
  349.     me->me_type = xstrdup (fsp->f_fstypename);
  350. #else
  351.     me->me_type = fstype_to_string (fsp->f_type);
  352. #endif
  353.     me->me_dev = (dev_t) -1;    /* Magic; means not known yet. */
  354.     me->me_next = NULL;
  355.  
  356.     /* Add to the linked list. */
  357.     mtail->me_next = me;
  358.     mtail = me;
  359.     fsp++;
  360.       }
  361.   }
  362. #endif /* MOUNTED_GETMNTINFO */
  363.  
  364. #ifdef MOUNTED_GETMNT        /* Ultrix.  */
  365.   {
  366.     int offset = 0;
  367.     int val;
  368.     struct fs_data fsd;
  369.  
  370.     while ((val = getmnt (&offset, &fsd, sizeof (fsd), NOSTAT_MANY,
  371.               (char *) 0)) > 0)
  372.       {
  373.     me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
  374.     me->me_devname = xstrdup (fsd.fd_req.devname);
  375.     me->me_mountdir = xstrdup (fsd.fd_req.path);
  376.     me->me_type = gt_names[fsd.fd_req.fstype];
  377.     me->me_dev = fsd.fd_req.dev;
  378.     me->me_next = NULL;
  379.  
  380.     /* Add to the linked list. */
  381.     mtail->me_next = me;
  382.     mtail = me;
  383.       }
  384.     if (val < 0)
  385.       return NULL;
  386.   }
  387. #endif /* MOUNTED_GETMNT. */
  388.  
  389. #if defined (MOUNTED_GETFSSTAT)    /* __alpha running OSF_1 */
  390.   {
  391.     int numsys, counter, bufsize;
  392.     struct statfs *stats;
  393.  
  394.     numsys = getfsstat ((struct statfs *)0, 0L, MNT_WAIT);
  395.     if (numsys < 0)
  396.       return (NULL);
  397.  
  398.     bufsize = (1 + numsys) * sizeof (struct statfs);
  399.     stats = (struct statfs *)xmalloc (bufsize);
  400.     numsys = getfsstat (stats, bufsize, MNT_WAIT);
  401.  
  402.     if (numsys < 0)
  403.       {
  404.     free (stats);
  405.     return (NULL);
  406.       }
  407.  
  408.     for (counter = 0; counter < numsys; counter++)
  409.       {
  410.     me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
  411.     me->me_devname = xstrdup (stats[counter].f_mntfromname);
  412.     me->me_mountdir = xstrdup (stats[counter].f_mntonname);
  413.     me->me_type = mnt_names[stats[counter].f_type];
  414.     me->me_dev = (dev_t) -1;    /* Magic; means not known yet. */
  415.     me->me_next = NULL;
  416.  
  417.     /* Add to the linked list. */
  418.     mtail->me_next = me;
  419.     mtail = me;
  420.       }
  421.  
  422.     free (stats);
  423.   }
  424. #endif /* MOUNTED_GETFSSTAT */
  425.  
  426. #if defined (MOUNTED_FREAD) || defined (MOUNTED_FREAD_FSTYP) /* SVR[23].  */
  427.   {
  428.     struct mnttab mnt;
  429.     char *table = "/etc/mnttab";
  430.     FILE *fp;
  431.  
  432.     fp = fopen (table, "r");
  433.     if (fp == NULL)
  434.       return NULL;
  435.  
  436.     while (fread (&mnt, sizeof mnt, 1, fp) > 0)
  437.       {
  438.     me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
  439. #ifdef GETFSTYP            /* SVR3.  */
  440.     me->me_devname = xstrdup (mnt.mt_dev);
  441. #else
  442.     me->me_devname = xmalloc (strlen (mnt.mt_dev) + 6);
  443.     strcpy (me->me_devname, "/dev/");
  444.     strcpy (me->me_devname + 5, mnt.mt_dev);
  445. #endif
  446.     me->me_mountdir = xstrdup (mnt.mt_filsys);
  447.     me->me_dev = (dev_t) -1;    /* Magic; means not known yet. */
  448.     me->me_type = "";
  449. #ifdef GETFSTYP            /* SVR3.  */
  450.     if (need_fs_type)
  451.       {
  452.         struct statfs fsd;
  453.         char typebuf[FSTYPSZ];
  454.  
  455.         if (statfs (me->me_mountdir, &fsd, sizeof fsd, 0) != -1
  456.         && sysfs (GETFSTYP, fsd.f_fstyp, typebuf) != -1)
  457.           me->me_type = xstrdup (typebuf);
  458.       }
  459. #endif
  460.     me->me_next = NULL;
  461.  
  462.     /* Add to the linked list. */
  463.     mtail->me_next = me;
  464.     mtail = me;
  465.       }
  466.  
  467.     if (fclose (fp) == EOF)
  468.       return NULL;
  469.   }
  470. #endif /* MOUNTED_FREAD || MOUNTED_FREAD_FSTYP.  */
  471.  
  472. #ifdef MOUNTED_GETMNTTBL    /* DolphinOS goes it's own way */
  473.   {
  474.     struct mntent **mnttbl=getmnttbl(),**ent;
  475.     for (ent=mnttbl;*ent;ent++)
  476.       {
  477.     me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
  478.     me->me_devname = xstrdup ( (*ent)->mt_resource);
  479.     me->me_mountdir = xstrdup( (*ent)->mt_directory);
  480.     me->me_type =  xstrdup ((*ent)->mt_fstype);
  481.     me->me_dev = (dev_t) -1;    /* Magic; means not known yet. */
  482.     me->me_next = NULL;
  483.  
  484.     /* Add to the linked list. */
  485.     mtail->me_next = me;
  486.     mtail = me;
  487.       }
  488.     endmnttbl();
  489.   }
  490. #endif
  491.  
  492. #ifdef MOUNTED_GETMNTENT2    /* SVR4.  */
  493.   {
  494.     struct mnttab mnt;
  495.     char *table = MNTTAB;
  496.     FILE *fp;
  497.     int ret;
  498.  
  499.     fp = fopen (table, "r");
  500.     if (fp == NULL)
  501.       return NULL;
  502.  
  503.     while ((ret = getmntent (fp, &mnt)) == 0)
  504.       {
  505.     me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
  506.     me->me_devname = xstrdup (mnt.mnt_special);
  507.     me->me_mountdir = xstrdup (mnt.mnt_mountp);
  508.     me->me_type = xstrdup (mnt.mnt_fstype);
  509.     me->me_dev = (dev_t) -1;    /* Magic; means not known yet. */
  510.     me->me_next = NULL;
  511.  
  512.     /* Add to the linked list. */
  513.     mtail->me_next = me;
  514.     mtail = me;
  515.       }
  516.  
  517.     if (ret > 0)
  518.       return NULL;
  519.    if (fclose (fp) == EOF)
  520.       return NULL;
  521.   }
  522. #endif /* MOUNTED_GETMNTENT2.  */
  523.  
  524. #ifdef MOUNTED_VMOUNT        /* AIX.  */
  525.   {
  526.     int bufsize;
  527.     char *entries, *thisent;
  528.     struct vmount *vmp;
  529.  
  530.     /* Ask how many bytes to allocate for the mounted filesystem info.  */
  531.     mntctl (MCTL_QUERY, sizeof bufsize, (struct vmount *) &bufsize);
  532.     entries = xmalloc (bufsize);
  533.  
  534.     /* Get the list of mounted filesystems.  */
  535.     mntctl (MCTL_QUERY, bufsize, (struct vmount *) entries);
  536.  
  537.     for (thisent = entries; thisent < entries + bufsize;
  538.      thisent += vmp->vmt_length)
  539.       {
  540.     vmp = (struct vmount *) thisent;
  541.     me = (struct mount_entry *) xmalloc (sizeof (struct mount_entry));
  542.     if (vmp->vmt_flags & MNT_REMOTE)
  543.       {
  544.         char *host, *path;
  545.  
  546.         /* Prepend the remote pathname.  */
  547.         host = thisent + vmp->vmt_data[VMT_HOSTNAME].vmt_off;
  548.         path = thisent + vmp->vmt_data[VMT_OBJECT].vmt_off;
  549.         me->me_devname = xmalloc (strlen (host) + strlen (path) + 2);
  550.         strcpy (me->me_devname, host);
  551.         strcat (me->me_devname, ":");
  552.         strcat (me->me_devname, path);
  553.       }
  554.     else
  555.       {
  556.         me->me_devname = xstrdup (thisent +
  557.                       vmp->vmt_data[VMT_OBJECT].vmt_off);
  558.       }
  559.     me->me_mountdir = xstrdup (thisent + vmp->vmt_data[VMT_STUB].vmt_off);
  560.     me->me_type = xstrdup (fstype_to_string (vmp->vmt_gfstype));
  561.     me->me_dev = (dev_t) -1; /* vmt_fsid might be the info we want.  */
  562.     me->me_next = NULL;
  563.  
  564.     /* Add to the linked list. */
  565.     mtail->me_next = me;
  566.     mtail = me;
  567.       }
  568.     free (entries);
  569.   }
  570. #endif /* MOUNTED_VMOUNT. */
  571.  
  572.   /* Free the dummy head. */
  573.   me = mount_list;
  574.   mount_list = mount_list->me_next;
  575.   free (me);
  576.   return mount_list;
  577. }
  578.